/*
  ******************************************************************************
  * @file    apt32f172_tc0_gpt.c
  * @author  APT AE Team
  * @version V1.12
  * @date    2019/03/08
  ******************************************************************************
  *THIS SOFTWARE WHICH IS FOR ILLUSTRATIVE PURPOSES ONLY WHICH PROVIDES 
  *CUSTOMER WITH CODING INFORMATION REGARDING THEIR PRODUCTS.
  *APT CHIP SHALL NOT BE HELD RESPONSIBILITY ADN LIABILITY FOR ANY DIRECT, 
  *INDIRECT DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT OF 
  *SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION 
  *CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.AND APT CHIP RESERVES 
  *THE RIGHT TO MAKE CHANGES IN THE SOFTWARE WITHOUT NOTIFICATION
  ******************************************************************************
  */

/* Define to prevent recursive inclusion -------------------------------------*/ 
#include "apt32f172_tc0_gpt.h"
/* defines -------------------------------------------------------------------*/

/* externs--------------------------------------------------------------------*/

/*************************************************************/
//GPT RESET VALUE
//EntryParameter:*GPTCHX
//*GPTCHX:GPTCH0,GPTCH1,GPTCH2
//ReturnValue:NONE
/*************************************************************/  
void GPT_RESET_VALUE(CSP_GPT_T *GPTCHX)									//reset value
{
	GPTCHX->ECR		=	GPT_ECR_RST;          		/**< ECR reset value       */
	GPTCHX->DCR		=	GPT_DCR_RST;	     	 	/**< DCR reset value       */
	GPTCHX->PMSR	=	GPT_PMSR_RST;	     		/**< PMSR reset value      */
	GPTCHX->CR		=	GPT_CR_RST;           		/**< CR reset value        */
	GPTCHX->MR		=	GPT_MR_RST;          		/**< MR reset value        */
	GPTCHX->CSR		= 	GPT_CSR_RST;         		/**< CSR reset value       */
	GPTCHX->SR 		=	GPT_SR_RST;           		/**< SR reset value        */
	GPTCHX->IER		=	GPT_IER_RST;          		/**< IER reset value       */
	GPTCHX->IDR		=	GPT_IDR_RST;          		/**< IDR reset value       */
	GPTCHX->IMR		=	GPT_IMR_RST;          		/**< IMR Rreset value      */
	GPTCHX->CV		=	GPT_CV_RST;           		/**< CV reset value        */
	GPTCHX->RA		= 	GPT_RA_RST;           	 	/**< RA reset value        */
	GPTCHX->RB		=	GPT_RB_RST;           	 	/**< RB reset value        */
	GPTCHX->RC		=	GPT_RC_RST;           		/**< RC reset value        */
	
	GPT->BCR	=	GPT_BCR_RST;          			/**< BCR reset value       */
	GPT->BMR	=	GPT_BMR_RST;          			/**< BMR reset value       */
}
/*************************************************************/
//GTC IO Init
//EntryParameter:GPT_IO_MODE_X,GPT_IO_G
//GPT_IO_MODE_X:GPT_IO_CLK0,GPT_IO_CLK1,GPT_IO_CLK2,GPT_IO_ETR,GPT_IO_IO0A,GPT_IO_IO0B,GPT_IO_IO1A,GPT_IO_IO1B,GPT_IO_IO2A,GPT_IO_IO2B
//GPT_IO_G;GPT_IO_CLK0(0->PA0.01(AF2) ;1->PD0.01(AF3)),GPT_IO_CLK1(0->PA0.15(AF3)),GPT_IO_CLK2(0->PC0.1(AF3))
//GPT_IO_ETR(0->PB0.1(AF2) ; 1->PC0.0(AF3))
//GPT_IO_IO0A(0->PB0.1(AF3) ; 1->PA0.3(AF4) ; 2->PD0.0(AF1) ; 3->PA1.0(AF2))
//GPT_IO_IO0B(0->PA0.0(AF3) ; 1->PA0.4(AF4) ; 2->PD0.1(AF1) ; 3->PA1.1(AF2))
//GPT_IO_IO1A(0->PA0.11(AF1) ; 1->PA1.2(AF2))
//GPT_IO_IO1B(0->PA0.12(AF1) ; 1->PA1.3(AF2))
//GPT_IO_IO2A(0->PA0.13(AF1) ; 1->PA1.4(AF2))
//GPT_IO_IO2B(0->PA0.14(AF1) ; 1->PA1.5(AF2))
//ReturnValue:NONE
/*************************************************************/
void GPT_IO_Init(GPT_IO_MODE_TypeDef  GPT_IO_MODE_X , U8_T GPT_IO_G )
{
	if(GPT_IO_MODE_X==GPT_IO_CLK0)
	{
		if(GPT_IO_G==0)
		{
			GPIOA0->CONLR=(GPIOA0->CONLR & 0XFFFFFF0F)|0x00000050;										//GPT_IO_CLK0(PA0.1->AF2)
		}
		else if(GPT_IO_G==1)
		{
			GPIOD0->CONLR=(GPIOD0->CONLR & 0XFFFFFF0F)|0x00000060;										//GPT_IO_CLK0(PD0.1->AF3)
		}
	}
	else if(GPT_IO_MODE_X==GPT_IO_CLK1)
	{
		if(GPT_IO_G==0)
		{
			GPIOA0->CONHR=(GPIOA0->CONHR & 0X0FFFFFFF)|0x60000000;										//GPT_IO_CLK1(PA0.15->AF3)
		}
	}
	else if(GPT_IO_MODE_X==GPT_IO_CLK2)
	{
		if(GPT_IO_G==0)
		{
			GPIOC0->CONLR=(GPIOC0->CONLR & 0XFFFFFF0F)|0x00000060;										//GPT_IO_CLK2(PC0.1->AF3)
		}
	}
	else if(GPT_IO_MODE_X==GPT_IO_ETR)
	{
		if(GPT_IO_G==0)
		{
			GPIOB0->CONLR=(GPIOB0->CONLR & 0XFFFFFF0F)|0x00000050;										//GPT_IO_ETR(PB0.1->AF2)
		}
		else if(GPT_IO_G==1)
		{
			GPIOC0->CONLR=(GPIOC0->CONLR & 0XFFFFFFF0)|0x00000006;										//GPT_IO_ETR(PC0.0->AF3)
		}
	}
	else if(GPT_IO_MODE_X==GPT_IO_IO0A)
	{
		if(GPT_IO_G==0)
		{
			GPIOB0->CONLR=(GPIOB0->CONLR & 0XFFFFFF0F)|0x00000060;										//GPT_IO_IO0A(PB0.1->AF3)
		}
		else if(GPT_IO_G==1)
		{
			GPIOA0->CONLR=(GPIOA0->CONLR & 0XFFFF0FFF)|0x00007000;										//GPT_IO_IO0A(PA0.3->AF4)
		}
		else if(GPT_IO_G==2)
		{
			GPIOD0->CONLR=(GPIOD0->CONLR & 0XFFFFFFF0)|0x00000004;										//GPT_IO_IO0A(PD0.0->AF1)
		}
		else if(GPT_IO_G==3)
		{
			GPIOA1->CONLR=(GPIOA1->CONLR & 0XFFFFFFF0)|0x00000005;										//GPT_IO_IO0A(PA1.0->AF2)
		}
	}
	else if(GPT_IO_MODE_X==GPT_IO_IO0B)
	{
		if(GPT_IO_G==0)
		{
			GPIOA0->CONLR=(GPIOA0->CONLR & 0XFFFFFFF0)|0x00000006;										//GPT_IO_IO0B(PA0.0->AF3)
		}
		else if(GPT_IO_G==1)
		{
			GPIOA0->CONLR=(GPIOA0->CONLR & 0XFFF0FFFF)|0x00070000;										//GPT_IO_IO0B(PA0.4->AF4)
		}
		else if(GPT_IO_G==2)
		{
			GPIOD0->CONLR=(GPIOD0->CONLR & 0XFFFFFF0F)|0x00000040;										//GPT_IO_IO0B(PD0.1->AF1)
		}
		else if(GPT_IO_G==3)
		{
			GPIOA1->CONLR=(GPIOA1->CONLR & 0XFFFFFF0F)|0x00000050;										//GPT_IO_IO0B(PA1.1->AF2)
		}
	}
	else if(GPT_IO_MODE_X==GPT_IO_IO1A)
	{
		if(GPT_IO_G==0)
		{
			GPIOA0->CONHR=(GPIOA0->CONHR & 0XFFFF0FFF)|0x00004000;										//GPT_IO_IO1A(PA0.11->AF1)
		}
		else if(GPT_IO_G==1)
		{
			GPIOA1->CONLR=(GPIOA1->CONLR & 0XFFFFF0FF)|0x00000500;										//GPT_IO_IO1A(PA1.2->AF2)
		}
	}
	else if(GPT_IO_MODE_X==GPT_IO_IO1B)
	{
		if(GPT_IO_G==0)
		{
			GPIOA0->CONHR=(GPIOA0->CONHR & 0XFFF0FFFF)|0x00040000;										//GPT_IO_IO1A(PA0.12->AF1)
		}
		else if(GPT_IO_G==1)
		{
			GPIOA1->CONLR=(GPIOA1->CONLR & 0XFFFF0FFF)|0x00005000;										//GPT_IO_IO1A(PA1.3->AF2)
		}
	}
	else if(GPT_IO_MODE_X==GPT_IO_IO2A)
	{
		if(GPT_IO_G==0)
		{
			GPIOA0->CONHR=(GPIOA0->CONHR & 0XFF0FFFFF)|0x00400000;										//GPT_IO_IO2A(PA0.13->AF1)
		}
		else if(GPT_IO_G==1)
		{
			GPIOA1->CONLR=(GPIOA1->CONLR & 0XFFF0FFFF)|0x00050000;										//GPT_IO_IO2A(PA1.4->AF2)
		}
	}
	else if(GPT_IO_MODE_X==GPT_IO_IO2B)
	{
		if(GPT_IO_G==0)
		{
			GPIOA0->CONHR=(GPIOA0->CONHR & 0XF0FFFFFF)|0x04000000;										//GPT_IO_IO2B(PA0.14->AF1)
		}
		else if(GPT_IO_G==1)
		{
			GPIOA1->CONLR=(GPIOA1->CONLR & 0XFF0FFFFF)|0x00500000;										//GPT_IO_IO1A(PA1.5->AF2)
		}
	}
}

/*************************************************************/
//all GPT software reset
//EntryParameter:
//ReturnValue:NONE
/*************************************************************/ 
void All_GPT_SoftwareReset(void)
{
	GPT->BCR = 0x01;							// all GPT Software reset
}
/*************************************************************/
//all GPT SWTRG
//EntryParameter:
//ReturnValue:NONE
/*************************************************************/ 
void All_GPT_SWTRG(void)
{
	GPT->BCR = 0x02;							// all GPT SWTRG
}
/*************************************************************/
//GPTCHX SWTRG
//EntryParameter:*GPTCHX
//*GPTCHX:GPTCH0,GPTCH1,GPTCH2
//ReturnValue:NONE
/*************************************************************/ 
void GPTCHX_SWTRG(CSP_GPT_T *GPTCHX)
{
	GPTCHX->CR = 0x08;							//GPTCHX SWTRG
}
/*************************************************************/
//GPTCHX software reset
//EntryParameter:*GPTCHX
//*GPTCHX:GPTCH0,GPTCH1,GPTCH2
//ReturnValue:NONE
/*************************************************************/ 
void GPTCHX_SoftwareReset(CSP_GPT_T *GPTCHX)
{
	GPTCHX->CR = 0x01;							//GPTCHX Software reset
}
/*************************************************************/
//GPTCHX Count clk CMD
//EntryParameter:*GPTCHX,NewState
//*GPTCHX:GPTCH0,GPTCH1,GPTCH2
//NewState:DISABLE,ENABLE
//ReturnValue:NONE
/*************************************************************/ 
void GPTCHX_CountClk_CMD(CSP_GPT_T *GPTCHX , FunctionalStatus NewState)
{
	if(NewState != DISABLE)
	{
		GPTCHX->CR = 0x02;							//enable counter clk 
	}
	else
	{
		GPTCHX->CR = 0x04;							//Disable counter clk 
	}
}
/*************************************************************/
//GPTCHX CLK CMD
//EntryParameter:*GPTCHX,NewState
//*GPTCHX:GPTCH0,GPTCH1,GPTCH2
//NewState:DISABLE,ENABLE
//ReturnValue:NONE
/*************************************************************/
void GPTCHX_Clk_CMD(CSP_GPT_T *GPTCHX , FunctionalStatus NewState)
{
	if(NewState != DISABLE)
	{
		GPTCHX->ECR	=0X02;									//GPT CLK enable
		while(!(GPTCHX->PMSR&0X02));
	}
	else 
	{
		GPTCHX->DCR	=0X02;									//GPT CLK disable
		while(GPTCHX->PMSR&0X02);
	}
}
/*************************************************************/
//GPTCHX counter read
//EntryParameter:*GPTCHX
//*GPTCHX:GPTCH0,GPTCH1,GPTCH2
//ReturnValue:Counter value
/*************************************************************/ 
/*U32_T GPTCHX_Counter_Value(CSP_GPT_T *GPTCHX)
{
	return (GPTCHX->CV);
}*/
/*************************************************************/
//GPT RA,RB,RC SET
//EntryParameter:*GPTCHX,load_RA,load_RB,load_RC
//*GPTCHX:GPTCH0,GPTCH1,GPTCH2
//load_RA:0~0xffff
//load_RB:0~0xffff
//load_RC:0~0xffff
//ReturnValue:NONE
/*************************************************************/ 
void GPTCHX_Set_RA_RB_RC(CSP_GPT_T *GPTCHX , U16_T load_RA , U16_T load_RB , U16_T load_RC)
{
	GPTCHX->RA = load_RA;											//Set GPT RA
	GPTCHX->RB = load_RB;											//Set GPT RB
	GPTCHX->RC = load_RC;											//Set GPT RC
}
/*************************************************************/
//GPT RA read
//EntryParameter:*GPTCHX
//ReturnValue:NONE
/*************************************************************/ 
/*U32_T GPT_RA_Value(CSP_GPT_T *GPTCHX)
{
	return (GPTCHX->RA);
}*/
/*************************************************************/
//GPT RB read
//EntryParameter:*GPTCHX
//ReturnValue:NONE
/*************************************************************/ 
/*U32_T GPT_RB_Value(CSP_GPT_T *GPTCHX)
{
	return (GPTCHX->RB);
}*/
/*************************************************************/
//GPT RC read
//EntryParameter:*GPTCHX
//ReturnValue:NONE
/*************************************************************/ 
/*U32_T GPT_RC_Value(CSP_GPT_T *GPTCHX)
{
	return (GPTCHX->RC);
}*/
/*************************************************************/
//GPTCHX CLK Configure
//EntryParameter:*GPTCHX,GPT_Mclk_Selecte_TypeDef,GptClks_Selecte_TypeDef,GPTCHX_CLKI_X,GPTCHX_BURST_SET_X
//*GPTCHX:GPTCH0,GPTCHX1,GPTCH2
//GPT_Mclk_Selecte_TypeDef:GPT_Mclk_Selecte_Pclk,GPT_Mclk_Selecte_HFOSC
//GptClks_Selecte_TypeDef:GptClks_MCLK_DIV1,GptClks_MCLK_DIV4,GptClks_MCLK_DIV32,GptClks_MCLK_DIV128,GptClks_MCLK_DIV1024,
//						  GptClks_XC0,GptClks_XC1,GptClks_XC2
//GPTCHX_CLKI_X:GPTCHX_CLKI_0,GPTCHX_CLKI_1
//GPTCHX_BURST_SET_X:GPTCHX_BURST_SET_None,GPTCHX_BURST_SET_XC0,GPTCHX_BURST_SET_XC1,GPTCHX_BURST_SET_XC2
//ReturnValue:NONE
/*************************************************************/
void GPTCHX_CLK_Configure(CSP_GPT_T *GPTCHX , GPT_Mclk_Selecte_TypeDef GPT_Mclk_Selecte_X , GptClks_Selecte_TypeDef GptClks_Selecte_X ,
						GPTCHX_CLKI_SET_TypeDef GPTCHX_CLKI_X , GPTCHX_BURST_SET_TypeDef GPTCHX_BURST_SET_X)
{
	GPTCHX->MR=GPTCHX->MR&0XFFFFFFC0;
	GPTCHX->MR|=GptClks_Selecte_X|GPTCHX_CLKI_X|GPTCHX_BURST_SET_X;
	GPT->BMR=GPT->BMR&0xFFFFFEFF;
	GPT->BMR|=GPT_Mclk_Selecte_X;								//MCLK选择PCLK或者96MHz		
	if(GPT_Mclk_Selecte_X==GPT_Mclk_Selecte_HFOSC)				//若选择96MHz需要增加配置
	{
		SYSCON->CLCR|=(0X01<<20);
		while(!(SYSCON->CLCR&(0x01<<21)));
	}
}
/*************************************************************/
//外部时钟XC0~XC2源选择
//EntryParameter:ETRG_XCn_Selected_X,ETRG_XCn_Selected_input
//XCn_Configure:XC0_Configure,XC1_Configure,XC2_Configure
//XCn_Selecte_x:XC0_Selecte_TCLK0,XC0_Selecte_TIOA1,XC0_Selecte_TIOA2,
//				XC1_Selecte_TCLK1,XC1_Selecte_TIOA0,XC1_Selecte_TIOA2,
//				XC2_Selecte_TCLK2,XC2_Selecte_TIOA0,XC2_Selecte_TIOA1,
//ReturnValue:NONE
/*************************************************************/ 
void GPTCHX_XCn_Configure(XCn_Configure_TypeDef XCn_Configure , XCn_Selecte_TypeDef XCn_Selecte_x)
{
	if(XCn_Configure==XC0_Configure)
	{
		GPT->BMR=GPT->BMR&0xFFFFFFFC;
		GPT->BMR|=XCn_Selecte_x;
	}	
	else if(XCn_Configure==XC1_Configure)
	{
		GPT->BMR=GPT->BMR&0xFFFFFFF3;
		GPT->BMR|=XCn_Selecte_x;
	}
	else if(XCn_Configure==XC2_Configure)
	{
		GPT->BMR=GPT->BMR&0xFFFFFFCF;
		GPT->BMR|=XCn_Selecte_x;
	}
}
/*************************************************************/
//GPTCHX Count Configure
//EntryParameter:*GPTCHX,
//CPC_Reload_CMD:CPC_Reload_DISABLE,CPC_Reload_ENABLE
//ReturnValue:NONE
/*************************************************************/ 
void GPTCHX_COUNT_Configure(CSP_GPT_T *GPTCHX , CPC_TRG_CMD_TypeDef CPC_Reload_CMD)
{
	GPTCHX->MR|=CPC_Reload_CMD;
}
/*************************************************************/
//GPT PWM Configure
//EntryParameter:*GPTCHX,CPC_STOP_CMD,CPC_DisCountClk_CMD,EEVT_Reload_CMD,EEVT_Reload_CMD,EEVT_SET_X,TIOA_SWTRG_OutPutX,TIOA_EEVT_OutPutX,TIOA_CPA_OutPutX,TIOA_CPC_OutPutX
//*GPTCHX:GPTCH0,GPTCHX1,GPTCH2
//CPC_STOP_CMD:CPC_STOP_DISABLE,CPC_STOP_ENABLE
//CPC_DisCountClk_CMD:CPC_DisCountClk_DISABLE,CPC_DisCountClk_ENABLE
//CPC_Reload_CMD:CPC_Reload_DISABLE,CPC_Reload_ENABLE
//EEVT_Reload_CMD:EEVT_Reload_ENABLE,EEVT_Reload_DISABLE
//EEVT_SET_X:EEVT_TIOB_NONE,EEVT_TIOB_Rise,EEVT_TIOB_Fall,EEVT_TIOB_Rise_Fall
//           EEVT_XC0_NONE,EEVT_XC0_Rise,EEVT_XC0_Fall,EEVT_XC0_Rise_Fall
//           EEVT_XC1_NONE,EEVT_XC1_Rise,EEVT_XC1_Fall,EEVT_XC1_Rise_Fall
//           EEVT_XC2_NONE,EEVT_XC2_Rise,EEVT_XC2_Fall,EEVT_XC2_Rise_Fall
//TIOA_SWTRG_OutPutX:TIOA_SWTRG_OutPut_NoChange,TIOA_SWTRG_OutPut_High,TIOA_SWTRG_OutPut_Low,TIOA_SWTRG_OutPut_Negate
//TIOA_EEVT_OutPutX:TIOA_EEVT_OutPut_NoChange,TIOA_EEVT_OutPut_High,TIOA_EEVT_OutPut_Low,TIOA_EEVT_OutPut_Negate
//TIOA_CPA_OutPutX:TIOA_CPA_OutPut_NoChange,TIOA_CPA_OutPut_High,TIOA_CPA_OutPut_Low,TIOA_CPA_OutPut_Negate
//TIOA_CPC_OutPutX:TIOA_CPC_OutPut_NoChange,TIOA_CPC_OutPut_High,TIOA_CPC_OutPut_Low,TIOA_CPC_OutPut_Negate
//TIOB_SWTRG_OutPutX:TIOB_SWTRG_OutPut_NoChange,TIOB_SWTRG_OutPut_High,TIOB_SWTRG_OutPut_Low,TIOB_SWTRG_OutPut_Negate
//TIOB_EEVT_OutPutX:TIOB_EEVT_OutPut_NoChange,TIOB_EEVT_OutPut_High,TIOB_EEVT_OutPut_Low,TIOB_EEVT_OutPut_Negate
//TIOB_CPB_OutPutX:TIOB_CPB_OutPut_NoChange,TIOB_CPB_OutPut_High,TIOB_CPB_OutPut_Low,TIOB_CPB_OutPut_Negate
//TIOB_CPC_OutPutX:TIOB_CPC_OutPut_NoChange,TIOB_CPC_OutPut_High,TIOB_CPC_OutPut_Low,TIOB_CPC_OutPut_Negate
//ReturnValue:NONE
/*************************************************************/ 
void GPTCHX_PWM_Configure(CSP_GPT_T *GPTCHX , CPC_STOP_CMD_TypeDef CPC_STOP_CMD , CPC_DisCountClk_CMD_TypeDef CPC_DisCountClk_CMD , CPC_TRG_CMD_TypeDef CPC_Reload_CMD , ENETRG_CMD_TypeDef EEVT_Reload_CMD , EEVT_SET_TypeDef EEVT_SET_X ,
						 TIOA_SWTRG_OutPutX_TypeDef TIOA_SWTRG_OutPutX , TIOA_EEVT_OutPutX_TypeDef TIOA_EEVT_OutPutX , TIOA_CPA_OutPutX_TypeDef TIOA_CPA_OutPutX , TIOA_CPC_OutPutX_TypeDef TIOA_CPC_OutPutX ,
						 TIOB_SWTRG_OutPutX_TypeDef TIOB_SWTRG_OutPutX , TIOB_EEVT_OutPutX_TypeDef TIOB_EEVT_OutPutX , TIOB_CPB_OutPutX_TypeDef TIOB_CPB_OutPutX , TIOB_CPC_OutPutX_TypeDef TIOB_CPC_OutPutX)
{
	GPTCHX->MR=GPTCHX->MR&0X0000003F;
	GPTCHX->MR|=(0X01<<15)|CPC_STOP_CMD|CPC_DisCountClk_CMD|CPC_Reload_CMD|TIOA_SWTRG_OutPutX|TIOA_EEVT_OutPutX|TIOA_CPA_OutPutX|TIOA_CPC_OutPutX
					|TIOB_SWTRG_OutPutX|TIOB_EEVT_OutPutX|TIOB_CPB_OutPutX|TIOB_CPC_OutPutX;
	if(EEVT_Reload_CMD==EEVT_Reload_ENABLE)
	{
		GPTCHX->MR|=(0x00<<12);
	}
	else
	{
		GPTCHX->MR|=(0x01<<12);
	}
	if(EEVT_SET_X==EEVT_TIOB_NONE)
	{
		GPTCHX->MR|=(0x00<<10)|(0x00<<8);
	}
	else if(EEVT_SET_X==EEVT_TIOB_Rise)
	{
		GPTCHX->MR|=(0x00<<10)|(0x01<<8);
	}
	else if(EEVT_SET_X==EEVT_TIOB_Fall)
	{
		GPTCHX->MR|=(0x00<<10)|(0x02<<8);
	}
	else if(EEVT_SET_X==EEVT_TIOB_Rise_Fall)
	{
		GPTCHX->MR|=(0x00<<10)|(0x03<<8);
	}
	else if(EEVT_SET_X==EEVT_XC0_NONE)
	{
		GPTCHX->MR|=(0x01<<10)|(0x00<<8);
	}
	else if(EEVT_SET_X==EEVT_XC0_Rise)
	{
		GPTCHX->MR|=(0x01<<10)|(0x01<<8);
	}
	else if(EEVT_SET_X==EEVT_XC0_Fall)
	{
		GPTCHX->MR|=(0x01<<10)|(0x02<<8);
	}
	else if(EEVT_SET_X==EEVT_XC0_Rise_Fall)
	{
		GPTCHX->MR|=(0x01<<10)|(0x03<<8);
	}
	else if(EEVT_SET_X==EEVT_XC1_NONE)
	{
		GPTCHX->MR|=(0x02<<10)|(0x00<<8);
	}
	else if(EEVT_SET_X==EEVT_XC1_Rise)
	{
		GPTCHX->MR|=(0x02<<10)|(0x01<<8);
	}
	else if(EEVT_SET_X==EEVT_XC1_Fall)
	{
		GPTCHX->MR|=(0x02<<10)|(0x02<<8);
	}
	else if(EEVT_SET_X==EEVT_XC1_Rise_Fall)
	{
		GPTCHX->MR|=(0x02<<10)|(0x03<<8);
	}
	else if(EEVT_SET_X==EEVT_XC2_NONE)
	{
		GPTCHX->MR|=(0x03<<10)|(0x00<<8);
	}
	else if(EEVT_SET_X==EEVT_XC2_Rise)
	{
		GPTCHX->MR|=(0x03<<10)|(0x01<<8);
	}
	else if(EEVT_SET_X==EEVT_XC2_Fall)
	{
		GPTCHX->MR|=(0x03<<10)|(0x02<<8);
	}
	else if(EEVT_SET_X==EEVT_XC2_Rise_Fall)
	{
		GPTCHX->MR|=(0x03<<10)|(0x03<<8);
	}
}
/*************************************************************/
//GPTCHX Capture Configure
//EntryParameter:*GPTCHX,CPC_TRG_CMD,LDB_STOP_CMD_X,LDB_DIS_CMD_X,ABETRG_SET_X,LDRA_SET_X,LDRB_SET_X
//*GPTCHX:GPTCH0,GPTCHX1,GPTCH2
//CPC_Reload_CMD:CPC_Reload_DISABLE,CPC_Reload_ENABLE
//LDB_STOP_CMD_X:LDB_STOP_DISABLE,LDB_STOP_ENABLE
//LDB_DIS_CMD_X:LDB_DisCountClk_DISABLE,LDB_DisCountClk_ENABLE
//ABETRG_SET_X:ABETRG_TIOA_NONE,ABETRG_TIOA_Rise,ABETRG_TIOA_Fall,ABETRG_TIOA_Rise_Fall,ABETRG_TIOB_NONE,ABETRG_TIOB_Rise,ABETRG_TIOB_Fall,ABETRG_TIOB_Rise_Fall
//LDRA_TIOA_SET_X:LDRA_TIOA_NONE,LDRA_TIOA_Rise,LDRA_TIOA_Fall,LDRA_TIOA_Rise_Fall
//LDRB_TIOA_SET_X:LDRB_TIOA_NONE,LDRB_TIOA_Rise,LDRB_TIOA_Fall,LDRB_TIOA_Rise_Fall
//ReturnValue:NONE
/*************************************************************/ 
void GPTCHX_Capture_Configure(CSP_GPT_T *GPTCHX , LDB_STOP_CMD_TypeDef LDB_STOP_CMD_X , LDB_DISCountClk_CMD_TypeDef LDB_DIS_CMD_X , 
		ABETRG_SET_TypeDef ABETRG_SET_X , CPC_TRG_CMD_TypeDef CPC_Reload_CMD , LDRA_TIOA_SET_TypeDef LDRA_TIOA_SET_X , LDRB_TIOA_SET_TypeDef LDRB_TIOA_SET_X)
{
	GPTCHX->MR=GPTCHX->MR&0X0000003F;
	GPTCHX->MR|=CPC_Reload_CMD|LDB_STOP_CMD_X|LDB_DIS_CMD_X|LDRA_TIOA_SET_X|LDRB_TIOA_SET_X;
	if(ABETRG_SET_X==ABETRG_TIOA_NONE)
	{
		GPTCHX->MR|=(0x01<<10)|(0x00<<8);
	}
	else if(ABETRG_SET_X==ABETRG_TIOA_Rise)
	{
		GPTCHX->MR|=(0x01<<10)|(0x01<<8);
	}
	else if(ABETRG_SET_X==ABETRG_TIOA_Fall)
	{
		GPTCHX->MR|=(0x01<<10)|(0x02<<8);
	}
	else if(ABETRG_SET_X==ABETRG_TIOA_Rise_Fall)
	{
		GPTCHX->MR|=(0x01<<10)|(0x03<<8);
	}
	else if(ABETRG_SET_X==ABETRG_TIOB_NONE)
	{
		GPTCHX->MR|=(0x00<<10)|(0x00<<8);
	}
	else if(ABETRG_SET_X==ABETRG_TIOB_Rise)
	{
		GPTCHX->MR|=(0x00<<10)|(0x01<<8);
	}
	else if(ABETRG_SET_X==ABETRG_TIOB_Fall)
	{
		GPTCHX->MR|=(0x00<<10)|(0x02<<8);
	}
	else if(ABETRG_SET_X==ABETRG_TIOB_Rise_Fall)
	{
		GPTCHX->MR|=(0x00<<10)|(0x03<<8);
	}
}
/*************************************************************/
//GPTCHX inturrpt Configure
//EntryParameter:*GPTCHX,GPTCHX_INT_X,NewState
//*GPTCHX:GPTCH0,GPTCHX1,GPTCH2
//GPTCHX_INT_X:GPTCHX_INT_COVFS,GPTCHX_INT_LOVRS,GPTCHX_INT_CPAS,GPTCHX_INT_CPBS,
//GPTCHX_INT_CPCS,GPTCHX_INT_LDRAS,GPTCHX_INT_LDRBS,GPTCHX_INT_ETRGS
//NewState:ENABLE,DISABLE
//ReturnValue:NONE
/*************************************************************/ 
void GPTCHX_ConfigInterrupt_CMD(CSP_GPT_T *GPTCHX , GPTCHX_INT_TypeDef GPTCHX_INT_X , FunctionalStatus NewState)
{
	if (NewState != DISABLE)
	{
		GPTCHX->IER  = GPTCHX_INT_X;					//SET
		while(!(GPTCHX->IMR&GPTCHX_INT_X));
	}
	else
	{
		GPTCHX->IDR  =	GPTCHX_INT_X;					//CLR
		while(GPTCHX->IMR&GPTCHX_INT_X);
	}
}
/*************************************************************/
//GPTCH0 Interrupt enable
//EntryParameter:NONE
//ReturnValue:NONE
/*************************************************************/
void GPTCH0_Int_Enable(void)
{
    INTC_ISER_WRITE(TC0_0_INT);    
}
/*************************************************************/
//GPTCH1 Interrupt enable
//EntryParameter:NONE
//ReturnValue:NONE
/*************************************************************/
void GPTCH1_Int_Enable(void)
{
    INTC_ISER_WRITE(TC0_1_INT);    
}

/*************************************************************/
//GPTCH2 Interrupt enable
//EntryParameter:NONE
//ReturnValue:NONE
/*************************************************************/
void GPTCH2_Int_Enable(void)
{
    INTC_ISER_WRITE(TC0_2_INT);    
}
/*************************************************************/
//GPTCH0 Interrupt disable
//EntryParameter:NONE
//ReturnValue:NONE
/*************************************************************/
void GPTCH0_Int_Disable(void)
{
    INTC_ICER_WRITE(TC0_0_INT);    
}
/*************************************************************/
//GPTCH1 Interrupt disable
//EntryParameter:NONE
//ReturnValue:NONE
/*************************************************************/
void GPTCH1_Int_Disable(void)
{
    INTC_ICER_WRITE(TC0_1_INT);    
}
/*************************************************************/
//GPTCH2 Interrupt disable
//EntryParameter:NONE
//ReturnValue:NONE
/*************************************************************/
void GPTCH2_Int_Disable(void)
{
    INTC_ICER_WRITE(TC0_2_INT);    
}
/*************************************************************/
//GPTCH0 Interrupt wake up enable
//EntryParameter:NONE
//ReturnValue:NONE
/*************************************************************/
void GPTCH0_Wakeup_Enable(void)
{
    INTC_IWER_WRITE(TC0_0_INT);    
}
/*************************************************************/
//GPTCH0 Interrupt wake up enable
//EntryParameter:NONE
//ReturnValue:NONE
/*************************************************************/
void GPTCH0_Wakeup_Disable(void)
{
    INTC_IWDR_WRITE(TC0_0_INT);    
}
/*************************************************************/
//GPTCH1 Interrupt wake up enable
//EntryParameter:NONE
//ReturnValue:NONE
/*************************************************************/
void GPTCH1_Wakeup_Enable(void)
{
    INTC_IWER_WRITE(TC0_1_INT);    
}
/*************************************************************/
//GPTCH1 Interrupt wake up enable
//EntryParameter:NONE
//ReturnValue:NONE
/*************************************************************/
void GPTCH1_Wakeup_Disable(void)
{
    INTC_IWDR_WRITE(TC0_1_INT);    
}
/*************************************************************/
//GPTCH2 Interrupt wake up enable
//EntryParameter:NONE
//ReturnValue:NONE
/*************************************************************/
void GPTCH2_Wakeup_Enable(void)
{
    INTC_IWER_WRITE(TC0_2_INT);    
}
/*************************************************************/
//GPTCH2 Interrupt wake up enable
//EntryParameter:NONE
//ReturnValue:NONE
/*************************************************************/
void GPTCH2_Wakeup_Disable(void)
{
    INTC_IWDR_WRITE(TC0_2_INT);    
}

/******************* (C) COPYRIGHT 2018 APT Chip *****END OF FILE****/